home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Freeware / Adobe Air 1.5 / AdobeAIRInstaller.exe / setup.swf / scripts / mx / collections / ListCollectionView.as < prev    next >
Encoding:
Text File  |  2008-10-29  |  41.9 KB  |  1,476 lines
  1. package mx.collections
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.EventDispatcher;
  5.    import flash.utils.Proxy;
  6.    import flash.utils.flash_proxy;
  7.    import flash.utils.getQualifiedClassName;
  8.    import mx.collections.errors.CollectionViewError;
  9.    import mx.collections.errors.ItemPendingError;
  10.    import mx.core.IMXMLObject;
  11.    import mx.core.mx_internal;
  12.    import mx.events.CollectionEvent;
  13.    import mx.events.CollectionEventKind;
  14.    import mx.events.PropertyChangeEvent;
  15.    import mx.resources.IResourceManager;
  16.    import mx.resources.ResourceManager;
  17.    import mx.utils.ObjectUtil;
  18.    
  19.    use namespace mx_internal;
  20.    use namespace flash_proxy;
  21.    
  22.    public class ListCollectionView extends Proxy implements ICollectionView, IList, IMXMLObject
  23.    {
  24.       mx_internal static const VERSION:String = "3.0.0.0";
  25.       
  26.       private var autoUpdateCounter:int;
  27.       
  28.       private var _list:IList;
  29.       
  30.       private var _filterFunction:Function;
  31.       
  32.       protected var localIndex:Array;
  33.       
  34.       mx_internal var dispatchResetEvent:Boolean = true;
  35.       
  36.       private var pendingUpdates:Array;
  37.       
  38.       private var resourceManager:IResourceManager;
  39.       
  40.       private var eventDispatcher:EventDispatcher;
  41.       
  42.       private var revision:int;
  43.       
  44.       private var _sort:Sort;
  45.       
  46.       public function ListCollectionView(param1:IList = null)
  47.       {
  48.          resourceManager = ResourceManager.getInstance();
  49.          super();
  50.          eventDispatcher = new EventDispatcher(this);
  51.          this.list = param1;
  52.       }
  53.       
  54.       private function handlePendingUpdates() : void
  55.       {
  56.          var _loc1_:Array = null;
  57.          var _loc2_:CollectionEvent = null;
  58.          var _loc3_:int = 0;
  59.          var _loc4_:CollectionEvent = null;
  60.          var _loc5_:int = 0;
  61.          if(pendingUpdates)
  62.          {
  63.             _loc1_ = pendingUpdates;
  64.             pendingUpdates = null;
  65.             _loc3_ = 0;
  66.             while(_loc3_ < _loc1_.length)
  67.             {
  68.                _loc4_ = _loc1_[_loc3_];
  69.                if(_loc4_.kind == CollectionEventKind.UPDATE)
  70.                {
  71.                   if(!_loc2_)
  72.                   {
  73.                      _loc2_ = _loc4_;
  74.                   }
  75.                   else
  76.                   {
  77.                      _loc5_ = 0;
  78.                      while(_loc5_ < _loc4_.items.length)
  79.                      {
  80.                         _loc2_.items.push(_loc4_.items[_loc5_]);
  81.                         _loc5_++;
  82.                      }
  83.                   }
  84.                }
  85.                else
  86.                {
  87.                   listChangeHandler(_loc4_);
  88.                }
  89.                _loc3_++;
  90.             }
  91.             if(_loc2_)
  92.             {
  93.                listChangeHandler(_loc2_);
  94.             }
  95.          }
  96.       }
  97.       
  98.       public function removeEventListener(param1:String, param2:Function, param3:Boolean = false) : void
  99.       {
  100.          eventDispatcher.removeEventListener(param1,param2,param3);
  101.       }
  102.       
  103.       private function replaceItemsInView(param1:Array, param2:int, param3:Boolean = true) : void
  104.       {
  105.          var _loc4_:int = 0;
  106.          var _loc5_:Array = null;
  107.          var _loc6_:Array = null;
  108.          var _loc7_:int = 0;
  109.          var _loc8_:PropertyChangeEvent = null;
  110.          var _loc9_:CollectionEvent = null;
  111.          if(localIndex)
  112.          {
  113.             _loc4_ = int(param1.length);
  114.             _loc5_ = [];
  115.             _loc6_ = [];
  116.             _loc7_ = 0;
  117.             while(_loc7_ < _loc4_)
  118.             {
  119.                _loc8_ = param1[_loc7_];
  120.                _loc5_.push(_loc8_.oldValue);
  121.                _loc6_.push(_loc8_.newValue);
  122.                _loc7_++;
  123.             }
  124.             removeItemsFromView(_loc5_,param2,param3);
  125.             addItemsToView(_loc6_,param2,param3);
  126.          }
  127.          else
  128.          {
  129.             _loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  130.             _loc9_.kind = CollectionEventKind.REPLACE;
  131.             _loc9_.location = param2;
  132.             _loc9_.items = param1;
  133.             dispatchEvent(_loc9_);
  134.          }
  135.       }
  136.       
  137.       public function willTrigger(param1:String) : Boolean
  138.       {
  139.          return eventDispatcher.willTrigger(param1);
  140.       }
  141.       
  142.       private function getFilteredItemIndex(param1:Object) : int
  143.       {
  144.          var _loc4_:Object = null;
  145.          var _loc5_:int = 0;
  146.          var _loc6_:int = 0;
  147.          var _loc2_:int = list.getItemIndex(param1);
  148.          if(_loc2_ == 0)
  149.          {
  150.             return 0;
  151.          }
  152.          var _loc3_:int = _loc2_ - 1;
  153.          while(_loc3_ >= 0)
  154.          {
  155.             _loc4_ = list.getItemAt(_loc3_);
  156.             if(filterFunction(_loc4_))
  157.             {
  158.                _loc5_ = int(localIndex.length);
  159.                _loc6_ = 0;
  160.                while(_loc6_ < _loc5_)
  161.                {
  162.                   if(localIndex[_loc6_] == _loc4_)
  163.                   {
  164.                      return _loc6_ + 1;
  165.                   }
  166.                   _loc6_++;
  167.                }
  168.             }
  169.             _loc3_--;
  170.          }
  171.          return 0;
  172.       }
  173.       
  174.       mx_internal function findItem(param1:Object, param2:String, param3:Boolean = false) : int
  175.       {
  176.          var _loc4_:String = null;
  177.          if(!sort)
  178.          {
  179.             _loc4_ = resourceManager.getString("collections","itemNotFound");
  180.             throw new CollectionViewError(_loc4_);
  181.          }
  182.          if(localIndex.length == 0)
  183.          {
  184.             return param3 ? 0 : -1;
  185.          }
  186.          return sort.findItem(localIndex,param1,param2,param3);
  187.       }
  188.       
  189.       override flash_proxy function nextName(param1:int) : String
  190.       {
  191.          return (param1 - 1).toString();
  192.       }
  193.       
  194.       public function removeAll() : void
  195.       {
  196.          var _loc2_:int = 0;
  197.          var _loc1_:int = length;
  198.          if(_loc1_ > 0)
  199.          {
  200.             if(localIndex)
  201.             {
  202.                _loc2_ = _loc1_ - 1;
  203.                while(_loc2_ >= 0)
  204.                {
  205.                   removeItemAt(_loc2_);
  206.                   _loc2_--;
  207.                }
  208.             }
  209.             else
  210.             {
  211.                list.removeAll();
  212.             }
  213.          }
  214.       }
  215.       
  216.       override flash_proxy function hasProperty(param1:*) : Boolean
  217.       {
  218.          var index:int;
  219.          var n:Number = NaN;
  220.          var name:* = param1;
  221.          if(name is QName)
  222.          {
  223.             name = name.localName;
  224.          }
  225.          index = -1;
  226.          try
  227.          {
  228.             n = parseInt(String(name));
  229.             if(!isNaN(n))
  230.             {
  231.                index = int(n);
  232.             }
  233.          }
  234.          catch(e:Error)
  235.          {
  236.          }
  237.          if(index == -1)
  238.          {
  239.             return false;
  240.          }
  241.          return index >= 0 && index < length;
  242.       }
  243.       
  244.       [Bindable("collectionChange")]
  245.       public function getItemAt(param1:int, param2:int = 0) : Object
  246.       {
  247.          var _loc3_:String = null;
  248.          if(param1 < 0 || param1 >= length)
  249.          {
  250.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  251.             throw new RangeError(_loc3_);
  252.          }
  253.          if(localIndex)
  254.          {
  255.             return localIndex[param1];
  256.          }
  257.          if(list)
  258.          {
  259.             return list.getItemAt(param1,param2);
  260.          }
  261.          return null;
  262.       }
  263.       
  264.       private function moveItemInView(param1:Object, param2:Boolean = true, param3:Array = null) : void
  265.       {
  266.          var _loc4_:int = 0;
  267.          var _loc5_:int = 0;
  268.          var _loc6_:int = 0;
  269.          var _loc7_:CollectionEvent = null;
  270.          if(localIndex)
  271.          {
  272.             _loc4_ = -1;
  273.             _loc5_ = 0;
  274.             while(_loc5_ < localIndex.length)
  275.             {
  276.                if(localIndex[_loc5_] == param1)
  277.                {
  278.                   _loc4_ = _loc5_;
  279.                   break;
  280.                }
  281.                _loc5_++;
  282.             }
  283.             if(_loc4_ > -1)
  284.             {
  285.                localIndex.splice(_loc4_,1);
  286.             }
  287.             _loc6_ = addItemsToView([param1],_loc4_,false);
  288.             if(param2)
  289.             {
  290.                _loc7_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  291.                _loc7_.items.push(param1);
  292.                if(param3 && _loc6_ == _loc4_ && _loc6_ > -1)
  293.                {
  294.                   param3.push(param1);
  295.                   return;
  296.                }
  297.                if(_loc6_ > -1 && _loc4_ > -1)
  298.                {
  299.                   _loc7_.kind = CollectionEventKind.MOVE;
  300.                   _loc7_.location = _loc6_;
  301.                   _loc7_.oldLocation = _loc4_;
  302.                }
  303.                else if(_loc6_ > -1)
  304.                {
  305.                   _loc7_.kind = CollectionEventKind.ADD;
  306.                   _loc7_.location = _loc6_;
  307.                }
  308.                else if(_loc4_ > -1)
  309.                {
  310.                   _loc7_.kind = CollectionEventKind.REMOVE;
  311.                   _loc7_.location = _loc4_;
  312.                }
  313.                else
  314.                {
  315.                   param2 = false;
  316.                }
  317.                if(param2)
  318.                {
  319.                   dispatchEvent(_loc7_);
  320.                }
  321.             }
  322.          }
  323.       }
  324.       
  325.       public function contains(param1:Object) : Boolean
  326.       {
  327.          return getItemIndex(param1) != -1;
  328.       }
  329.       
  330.       [Bindable("sortChanged")]
  331.       public function get sort() : Sort
  332.       {
  333.          return _sort;
  334.       }
  335.       
  336.       private function removeItemsFromView(param1:Array, param2:int, param3:Boolean = true) : void
  337.       {
  338.          var _loc6_:int = 0;
  339.          var _loc7_:Object = null;
  340.          var _loc8_:int = 0;
  341.          var _loc9_:CollectionEvent = null;
  342.          var _loc4_:Array = !!localIndex ? [] : param1;
  343.          var _loc5_:int = param2;
  344.          if(localIndex)
  345.          {
  346.             _loc6_ = 0;
  347.             while(_loc6_ < param1.length)
  348.             {
  349.                _loc7_ = param1[_loc6_];
  350.                _loc8_ = getItemIndex(_loc7_);
  351.                if(_loc8_ > -1)
  352.                {
  353.                   localIndex.splice(_loc8_,1);
  354.                   _loc4_.push(_loc7_);
  355.                   _loc5_ = _loc8_;
  356.                }
  357.                _loc6_++;
  358.             }
  359.          }
  360.          if(param3 && _loc4_.length > 0)
  361.          {
  362.             _loc9_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  363.             _loc9_.kind = CollectionEventKind.REMOVE;
  364.             _loc9_.location = !localIndex || _loc4_.length == 1 ? _loc5_ : -1;
  365.             _loc9_.items = _loc4_;
  366.             dispatchEvent(_loc9_);
  367.          }
  368.       }
  369.       
  370.       [Bindable("listChanged")]
  371.       public function get list() : IList
  372.       {
  373.          return _list;
  374.       }
  375.       
  376.       public function addItemAt(param1:Object, param2:int) : void
  377.       {
  378.          var _loc4_:String = null;
  379.          if(param2 < 0 || !list || param2 > length)
  380.          {
  381.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  382.             throw new RangeError(_loc4_);
  383.          }
  384.          var _loc3_:int = param2;
  385.          if(Boolean(localIndex) && Boolean(sort))
  386.          {
  387.             _loc3_ = list.length;
  388.          }
  389.          else if(Boolean(localIndex) && filterFunction != null)
  390.          {
  391.             if(_loc3_ == localIndex.length)
  392.             {
  393.                _loc3_ = list.length;
  394.             }
  395.             else
  396.             {
  397.                _loc3_ = list.getItemIndex(localIndex[param2]);
  398.             }
  399.          }
  400.          list.addItemAt(param1,_loc3_);
  401.       }
  402.       
  403.       public function itemUpdated(param1:Object, param2:Object = null, param3:Object = null, param4:Object = null) : void
  404.       {
  405.          list.itemUpdated(param1,param2,param3,param4);
  406.       }
  407.       
  408.       private function populateLocalIndex() : void
  409.       {
  410.          if(list)
  411.          {
  412.             localIndex = list.toArray();
  413.          }
  414.          else
  415.          {
  416.             localIndex = [];
  417.          }
  418.       }
  419.       
  420.       private function handlePropertyChangeEvents(param1:Array) : void
  421.       {
  422.          var _loc3_:Array = null;
  423.          var _loc4_:Object = null;
  424.          var _loc5_:int = 0;
  425.          var _loc6_:Array = null;
  426.          var _loc7_:int = 0;
  427.          var _loc8_:PropertyChangeEvent = null;
  428.          var _loc9_:Object = null;
  429.          var _loc10_:* = false;
  430.          var _loc11_:int = 0;
  431.          var _loc12_:int = 0;
  432.          var _loc13_:CollectionEvent = null;
  433.          var _loc2_:Array = param1;
  434.          if(Boolean(sort) || filterFunction != null)
  435.          {
  436.             _loc3_ = [];
  437.             _loc5_ = 0;
  438.             while(_loc5_ < param1.length)
  439.             {
  440.                _loc8_ = param1[_loc5_];
  441.                if(_loc8_.target)
  442.                {
  443.                   _loc9_ = _loc8_.target;
  444.                   _loc10_ = _loc8_.target != _loc8_.source;
  445.                }
  446.                else
  447.                {
  448.                   _loc9_ = _loc8_.source;
  449.                   _loc10_ = false;
  450.                }
  451.                _loc11_ = 0;
  452.                while(_loc11_ < _loc3_.length)
  453.                {
  454.                   if(_loc3_[_loc11_].item == _loc9_)
  455.                   {
  456.                      break;
  457.                   }
  458.                   _loc11_++;
  459.                }
  460.                if(_loc11_ < _loc3_.length)
  461.                {
  462.                   _loc4_ = _loc3_[_loc11_];
  463.                }
  464.                else
  465.                {
  466.                   _loc4_ = {
  467.                      "item":_loc9_,
  468.                      "move":_loc10_,
  469.                      "event":_loc8_
  470.                   };
  471.                   _loc3_.push(_loc4_);
  472.                }
  473.                _loc4_.move = _loc4_.move || filterFunction || !_loc8_.property || sort && sort.propertyAffectsSort(String(_loc8_.property));
  474.                _loc5_++;
  475.             }
  476.             _loc2_ = [];
  477.             _loc5_ = 0;
  478.             while(_loc5_ < _loc3_.length)
  479.             {
  480.                _loc4_ = _loc3_[_loc5_];
  481.                if(_loc4_.move)
  482.                {
  483.                   moveItemInView(_loc4_.item,_loc4_.item,_loc2_);
  484.                }
  485.                else
  486.                {
  487.                   _loc2_.push(_loc4_.item);
  488.                }
  489.                _loc5_++;
  490.             }
  491.             _loc6_ = [];
  492.             _loc7_ = 0;
  493.             while(_loc7_ < _loc2_.length)
  494.             {
  495.                _loc12_ = 0;
  496.                while(_loc12_ < _loc3_.length)
  497.                {
  498.                   if(_loc2_[_loc7_] == _loc3_[_loc12_].item)
  499.                   {
  500.                      _loc6_.push(_loc3_[_loc12_].event);
  501.                   }
  502.                   _loc12_++;
  503.                }
  504.                _loc7_++;
  505.             }
  506.             _loc2_ = _loc6_;
  507.          }
  508.          if(_loc2_.length > 0)
  509.          {
  510.             _loc13_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  511.             _loc13_.kind = CollectionEventKind.UPDATE;
  512.             _loc13_.items = _loc2_;
  513.             dispatchEvent(_loc13_);
  514.          }
  515.       }
  516.       
  517.       public function set sort(param1:Sort) : void
  518.       {
  519.          _sort = param1;
  520.          dispatchEvent(new Event("sortChanged"));
  521.       }
  522.       
  523.       override flash_proxy function nextValue(param1:int) : *
  524.       {
  525.          return getItemAt(param1 - 1);
  526.       }
  527.       
  528.       public function setItemAt(param1:Object, param2:int) : Object
  529.       {
  530.          var _loc4_:String = null;
  531.          var _loc5_:Object = null;
  532.          if(param2 < 0 || !list || param2 >= length)
  533.          {
  534.             _loc4_ = resourceManager.getString("collections","outOfBounds",[param2]);
  535.             throw new RangeError(_loc4_);
  536.          }
  537.          var _loc3_:int = param2;
  538.          if(localIndex)
  539.          {
  540.             if(param2 > localIndex.length)
  541.             {
  542.                _loc3_ = list.length;
  543.             }
  544.             else
  545.             {
  546.                _loc5_ = localIndex[param2];
  547.                _loc3_ = list.getItemIndex(_loc5_);
  548.             }
  549.          }
  550.          return list.setItemAt(param1,_loc3_);
  551.       }
  552.       
  553.       mx_internal function getBookmark(param1:int) : ListCollectionViewBookmark
  554.       {
  555.          var value:Object = null;
  556.          var message:String = null;
  557.          var index:int = param1;
  558.          if(index < 0 || index > length)
  559.          {
  560.             message = resourceManager.getString("collections","invalidIndex",[index]);
  561.             throw new CollectionViewError(message);
  562.          }
  563.          try
  564.          {
  565.             value = getItemAt(index);
  566.          }
  567.          catch(e:Error)
  568.          {
  569.             value = null;
  570.          }
  571.          return new ListCollectionViewBookmark(value,this,revision,index);
  572.       }
  573.       
  574.       private function addItemsToView(param1:Array, param2:int, param3:Boolean = true) : int
  575.       {
  576.          var _loc7_:int = 0;
  577.          var _loc8_:int = 0;
  578.          var _loc9_:Object = null;
  579.          var _loc10_:String = null;
  580.          var _loc11_:CollectionEvent = null;
  581.          var _loc4_:Array = !!localIndex ? [] : param1;
  582.          var _loc5_:int = param2;
  583.          var _loc6_:Boolean = true;
  584.          if(localIndex)
  585.          {
  586.             _loc7_ = param2;
  587.             _loc8_ = 0;
  588.             while(_loc8_ < param1.length)
  589.             {
  590.                _loc9_ = param1[_loc8_];
  591.                if(filterFunction == null || filterFunction(_loc9_))
  592.                {
  593.                   if(sort)
  594.                   {
  595.                      _loc7_ = mx_internal::findItem(_loc9_,Sort.ANY_INDEX_MODE,true);
  596.                      if(_loc6_)
  597.                      {
  598.                         _loc5_ = _loc7_;
  599.                         _loc6_ = false;
  600.                      }
  601.                   }
  602.                   else
  603.                   {
  604.                      _loc7_ = getFilteredItemIndex(_loc9_);
  605.                      if(_loc6_)
  606.                      {
  607.                         _loc5_ = _loc7_;
  608.                         _loc6_ = false;
  609.                      }
  610.                   }
  611.                   if(sort && sort.unique && sort.compareFunction(_loc9_,localIndex[_loc7_]) == 0)
  612.                   {
  613.                      _loc10_ = resourceManager.getString("collections","incorrectAddition");
  614.                      throw new CollectionViewError(_loc10_);
  615.                   }
  616.                   localIndex.splice(_loc7_++,0,_loc9_);
  617.                   _loc4_.push(_loc9_);
  618.                }
  619.                else
  620.                {
  621.                   _loc5_ = -1;
  622.                }
  623.                _loc8_++;
  624.             }
  625.          }
  626.          if(Boolean(localIndex) && _loc4_.length > 1)
  627.          {
  628.             _loc5_ = -1;
  629.          }
  630.          if(param3 && _loc4_.length > 0)
  631.          {
  632.             _loc11_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  633.             _loc11_.kind = CollectionEventKind.ADD;
  634.             _loc11_.location = _loc5_;
  635.             _loc11_.items = _loc4_;
  636.             dispatchEvent(_loc11_);
  637.          }
  638.          return _loc5_;
  639.       }
  640.       
  641.       public function dispatchEvent(param1:Event) : Boolean
  642.       {
  643.          return eventDispatcher.dispatchEvent(param1);
  644.       }
  645.       
  646.       public function set list(param1:IList) : void
  647.       {
  648.          var _loc2_:* = false;
  649.          var _loc3_:* = false;
  650.          if(_list != param1)
  651.          {
  652.             if(_list)
  653.             {
  654.                _list.removeEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler);
  655.                _loc2_ = _list.length > 0;
  656.             }
  657.             _list = param1;
  658.             if(_list)
  659.             {
  660.                _list.addEventListener(CollectionEvent.COLLECTION_CHANGE,listChangeHandler,false,0,true);
  661.                _loc3_ = _list.length > 0;
  662.             }
  663.             if(_loc2_ || _loc3_)
  664.             {
  665.                mx_internal::reset();
  666.             }
  667.             dispatchEvent(new Event("listChanged"));
  668.          }
  669.       }
  670.       
  671.       mx_internal function getBookmarkIndex(param1:CursorBookmark) : int
  672.       {
  673.          var _loc3_:String = null;
  674.          if(!(param1 is ListCollectionViewBookmark) || ListCollectionViewBookmark(param1).mx_internal::view != this)
  675.          {
  676.             _loc3_ = resourceManager.getString("collections","bookmarkNotFound");
  677.             throw new CollectionViewError(_loc3_);
  678.          }
  679.          var _loc2_:ListCollectionViewBookmark = ListCollectionViewBookmark(param1);
  680.          if(_loc2_.mx_internal::viewRevision != revision)
  681.          {
  682.             if(_loc2_.mx_internal::index < 0 || _loc2_.mx_internal::index >= length || getItemAt(_loc2_.mx_internal::index) != _loc2_.value)
  683.             {
  684.                _loc2_.mx_internal::index = getItemIndex(_loc2_.value);
  685.             }
  686.             _loc2_.mx_internal::viewRevision = revision;
  687.          }
  688.          return _loc2_.mx_internal::index;
  689.       }
  690.       
  691.       public function addEventListener(param1:String, param2:Function, param3:Boolean = false, param4:int = 0, param5:Boolean = false) : void
  692.       {
  693.          eventDispatcher.addEventListener(param1,param2,param3,param4,param5);
  694.       }
  695.       
  696.       public function getItemIndex(param1:Object) : int
  697.       {
  698.          var _loc2_:int = 0;
  699.          var _loc3_:int = 0;
  700.          var _loc4_:int = 0;
  701.          var _loc5_:int = 0;
  702.          if(sort)
  703.          {
  704.             _loc3_ = sort.findItem(localIndex,param1,Sort.FIRST_INDEX_MODE);
  705.             if(_loc3_ == -1)
  706.             {
  707.                return -1;
  708.             }
  709.             _loc4_ = sort.findItem(localIndex,param1,Sort.LAST_INDEX_MODE);
  710.             _loc2_ = _loc3_;
  711.             while(_loc2_ <= _loc4_)
  712.             {
  713.                if(localIndex[_loc2_] == param1)
  714.                {
  715.                   return _loc2_;
  716.                }
  717.                _loc2_++;
  718.             }
  719.             return -1;
  720.          }
  721.          if(filterFunction != null)
  722.          {
  723.             _loc5_ = int(localIndex.length);
  724.             _loc2_ = 0;
  725.             while(_loc2_ < _loc5_)
  726.             {
  727.                if(localIndex[_loc2_] == param1)
  728.                {
  729.                   return _loc2_;
  730.                }
  731.                _loc2_++;
  732.             }
  733.             return -1;
  734.          }
  735.          return list.getItemIndex(param1);
  736.       }
  737.       
  738.       public function removeItemAt(param1:int) : Object
  739.       {
  740.          var _loc3_:String = null;
  741.          var _loc4_:Object = null;
  742.          if(param1 < 0 || param1 >= length)
  743.          {
  744.             _loc3_ = resourceManager.getString("collections","outOfBounds",[param1]);
  745.             throw new RangeError(_loc3_);
  746.          }
  747.          var _loc2_:int = param1;
  748.          if(localIndex)
  749.          {
  750.             _loc4_ = localIndex[param1];
  751.             _loc2_ = list.getItemIndex(_loc4_);
  752.          }
  753.          return list.removeItemAt(_loc2_);
  754.       }
  755.       
  756.       override flash_proxy function getProperty(param1:*) : *
  757.       {
  758.          var index:int;
  759.          var n:Number = NaN;
  760.          var message:String = null;
  761.          var name:* = param1;
  762.          if(name is QName)
  763.          {
  764.             name = name.localName;
  765.          }
  766.          index = -1;
  767.          try
  768.          {
  769.             n = parseInt(String(name));
  770.             if(!isNaN(n))
  771.             {
  772.                index = int(n);
  773.             }
  774.          }
  775.          catch(e:Error)
  776.          {
  777.          }
  778.          if(index == -1)
  779.          {
  780.             message = resourceManager.getString("collections","unknownProperty",[name]);
  781.             throw new Error(message);
  782.          }
  783.          return getItemAt(index);
  784.       }
  785.       
  786.       public function enableAutoUpdate() : void
  787.       {
  788.          if(autoUpdateCounter > 0)
  789.          {
  790.             --autoUpdateCounter;
  791.             if(autoUpdateCounter == 0)
  792.             {
  793.                handlePendingUpdates();
  794.             }
  795.          }
  796.       }
  797.       
  798.       mx_internal function reset() : void
  799.       {
  800.          var _loc1_:CollectionEvent = null;
  801.          internalRefresh(false);
  802.          if(mx_internal::dispatchResetEvent)
  803.          {
  804.             _loc1_ = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  805.             _loc1_.kind = CollectionEventKind.RESET;
  806.             dispatchEvent(_loc1_);
  807.          }
  808.       }
  809.       
  810.       public function toArray() : Array
  811.       {
  812.          var _loc1_:Array = null;
  813.          if(localIndex)
  814.          {
  815.             _loc1_ = localIndex.concat();
  816.          }
  817.          else
  818.          {
  819.             _loc1_ = list.toArray();
  820.          }
  821.          return _loc1_;
  822.       }
  823.       
  824.       override flash_proxy function callProperty(param1:*, ... rest) : *
  825.       {
  826.          return null;
  827.       }
  828.       
  829.       public function initialized(param1:Object, param2:String) : void
  830.       {
  831.          refresh();
  832.       }
  833.       
  834.       override flash_proxy function setProperty(param1:*, param2:*) : void
  835.       {
  836.          var index:int;
  837.          var n:Number = NaN;
  838.          var message:String = null;
  839.          var name:* = param1;
  840.          var value:* = param2;
  841.          if(name is QName)
  842.          {
  843.             name = name.localName;
  844.          }
  845.          index = -1;
  846.          try
  847.          {
  848.             n = parseInt(String(name));
  849.             if(!isNaN(n))
  850.             {
  851.                index = int(n);
  852.             }
  853.          }
  854.          catch(e:Error)
  855.          {
  856.          }
  857.          if(index == -1)
  858.          {
  859.             message = resourceManager.getString("collections","unknownProperty",[name]);
  860.             throw new Error(message);
  861.          }
  862.          setItemAt(value,index);
  863.       }
  864.       
  865.       public function addItem(param1:Object) : void
  866.       {
  867.          addItemAt(param1,length);
  868.       }
  869.       
  870.       private function internalRefresh(param1:Boolean) : Boolean
  871.       {
  872.          var tmp:Array = null;
  873.          var len:int = 0;
  874.          var i:int = 0;
  875.          var item:Object = null;
  876.          var refreshEvent:CollectionEvent = null;
  877.          var dispatch:Boolean = param1;
  878.          if(Boolean(sort) || filterFunction != null)
  879.          {
  880.             try
  881.             {
  882.                populateLocalIndex();
  883.             }
  884.             catch(pending:ItemPendingError)
  885.             {
  886.                pending.addResponder(new ItemResponder(function(param1:Object, param2:Object = null):void
  887.                {
  888.                   internalRefresh(dispatch);
  889.                },function(param1:Object, param2:Object = null):void
  890.                {
  891.                }));
  892.                return false;
  893.             }
  894.             if(filterFunction != null)
  895.             {
  896.                tmp = [];
  897.                len = int(localIndex.length);
  898.                i = 0;
  899.                while(i < len)
  900.                {
  901.                   item = localIndex[i];
  902.                   if(filterFunction(item))
  903.                   {
  904.                      tmp.push(item);
  905.                   }
  906.                   i++;
  907.                }
  908.                localIndex = tmp;
  909.             }
  910.             if(sort)
  911.             {
  912.                sort.sort(localIndex);
  913.                dispatch = true;
  914.             }
  915.          }
  916.          else if(localIndex)
  917.          {
  918.             localIndex = null;
  919.          }
  920.          ++revision;
  921.          pendingUpdates = null;
  922.          if(dispatch)
  923.          {
  924.             refreshEvent = new CollectionEvent(CollectionEvent.COLLECTION_CHANGE);
  925.             refreshEvent.kind = CollectionEventKind.REFRESH;
  926.             dispatchEvent(refreshEvent);
  927.          }
  928.          return true;
  929.       }
  930.       
  931.       public function set filterFunction(param1:Function) : void
  932.       {
  933.          _filterFunction = param1;
  934.          dispatchEvent(new Event("filterFunctionChanged"));
  935.       }
  936.       
  937.       public function refresh() : Boolean
  938.       {
  939.          return internalRefresh(true);
  940.       }
  941.       
  942.       [Bindable("filterFunctionChanged")]
  943.       public function get filterFunction() : Function
  944.       {
  945.          return _filterFunction;
  946.       }
  947.       
  948.       public function createCursor() : IViewCursor
  949.       {
  950.          return new ListCollectionViewCursor(this);
  951.       }
  952.       
  953.       public function hasEventListener(param1:String) : Boolean
  954.       {
  955.          return eventDispatcher.hasEventListener(param1);
  956.       }
  957.       
  958.       [Bindable("collectionChange")]
  959.       public function get length() : int
  960.       {
  961.          if(localIndex)
  962.          {
  963.             return localIndex.length;
  964.          }
  965.          if(list)
  966.          {
  967.             return list.length;
  968.          }
  969.          return 0;
  970.       }
  971.       
  972.       override flash_proxy function nextNameIndex(param1:int) : int
  973.       {
  974.          return param1 < length ? param1 + 1 : 0;
  975.       }
  976.       
  977.       public function disableAutoUpdate() : void
  978.       {
  979.          ++autoUpdateCounter;
  980.       }
  981.       
  982.       public function toString() : String
  983.       {
  984.          if(localIndex)
  985.          {
  986.             return ObjectUtil.toString(localIndex);
  987.          }
  988.          if(Boolean(list) && Boolean(Object(list).toString))
  989.          {
  990.             return Object(list).toString();
  991.          }
  992.          return getQualifiedClassName(this);
  993.       }
  994.       
  995.       private function listChangeHandler(param1:CollectionEvent) : void
  996.       {
  997.          if(autoUpdateCounter > 0)
  998.          {
  999.             if(!pendingUpdates)
  1000.             {
  1001.                pendingUpdates = [];
  1002.             }
  1003.             pendingUpdates.push(param1);
  1004.          }
  1005.          else
  1006.          {
  1007.             switch(param1.kind)
  1008.             {
  1009.                case CollectionEventKind.ADD:
  1010.                   addItemsToView(param1.items,param1.location);
  1011.                   break;
  1012.                case CollectionEventKind.RESET:
  1013.                   mx_internal::reset();
  1014.                   break;
  1015.                case CollectionEventKind.REMOVE:
  1016.                   removeItemsFromView(param1.items,param1.location);
  1017.                   break;
  1018.                case CollectionEventKind.REPLACE:
  1019.                   replaceItemsInView(param1.items,param1.location);
  1020.                   break;
  1021.                case CollectionEventKind.UPDATE:
  1022.                   handlePropertyChangeEvents(param1.items);
  1023.                   break;
  1024.                default:
  1025.                   dispatchEvent(param1);
  1026.             }
  1027.          }
  1028.       }
  1029.    }
  1030. }
  1031.  
  1032. import flash.events.EventDispatcher;
  1033. import mx.collections.errors.CollectionViewError;
  1034. import mx.collections.errors.CursorError;
  1035. import mx.collections.errors.ItemPendingError;
  1036. import mx.collections.errors.SortError;
  1037. import mx.core.mx_internal;
  1038. import mx.events.CollectionEvent;
  1039. import mx.events.CollectionEventKind;
  1040. import mx.events.FlexEvent;
  1041. import mx.resources.IResourceManager;
  1042. import mx.resources.ResourceManager;
  1043.  
  1044. use namespace mx_internal;
  1045.  
  1046. class ListCollectionViewBookmark extends CursorBookmark
  1047. {
  1048.    mx_internal var viewRevision:int;
  1049.    
  1050.    mx_internal var index:int;
  1051.    
  1052.    mx_internal var view:ListCollectionView;
  1053.    
  1054.    public function ListCollectionViewBookmark(param1:Object, param2:ListCollectionView, param3:int, param4:int)
  1055.    {
  1056.       super(param1);
  1057.       this.mx_internal::view = param2;
  1058.       this.mx_internal::viewRevision = param3;
  1059.       this.mx_internal::index = param4;
  1060.    }
  1061.    
  1062.    override public function getViewIndex() : int
  1063.    {
  1064.       return mx_internal::view.mx_internal::getBookmarkIndex(this);
  1065.    }
  1066. }
  1067.  
  1068. class ListCollectionViewCursor extends EventDispatcher implements IViewCursor
  1069. {
  1070.    private static const BEFORE_FIRST_INDEX:int = -1;
  1071.    
  1072.    private static const AFTER_LAST_INDEX:int = -2;
  1073.    
  1074.    private var _view:ListCollectionView;
  1075.    
  1076.    private var invalid:Boolean;
  1077.    
  1078.    private var resourceManager:IResourceManager;
  1079.    
  1080.    private var currentIndex:int;
  1081.    
  1082.    private var currentValue:Object;
  1083.    
  1084.    public function ListCollectionViewCursor(param1:ListCollectionView)
  1085.    {
  1086.       var view:ListCollectionView = param1;
  1087.       resourceManager = ResourceManager.getInstance();
  1088.       super();
  1089.       _view = view;
  1090.       _view.addEventListener(CollectionEvent.COLLECTION_CHANGE,collectionEventHandler,false,0,true);
  1091.       currentIndex = view.length > 0 ? 0 : int(AFTER_LAST_INDEX);
  1092.       if(currentIndex == 0)
  1093.       {
  1094.          try
  1095.          {
  1096.             setCurrent(view.getItemAt(0),false);
  1097.          }
  1098.          catch(e:ItemPendingError)
  1099.          {
  1100.             currentIndex = BEFORE_FIRST_INDEX;
  1101.             setCurrent(null,false);
  1102.          }
  1103.       }
  1104.    }
  1105.    
  1106.    public function findAny(param1:Object) : Boolean
  1107.    {
  1108.       var lcView:ListCollectionView;
  1109.       var index:int = 0;
  1110.       var values:Object = param1;
  1111.       checkValid();
  1112.       lcView = ListCollectionView(view);
  1113.       try
  1114.       {
  1115.          index = lcView.mx_internal::findItem(values,Sort.ANY_INDEX_MODE);
  1116.       }
  1117.       catch(e:SortError)
  1118.       {
  1119.          throw new CursorError(e.message);
  1120.       }
  1121.       if(index > -1)
  1122.       {
  1123.          currentIndex = index;
  1124.          setCurrent(lcView.getItemAt(currentIndex));
  1125.       }
  1126.       return index > -1;
  1127.    }
  1128.    
  1129.    public function remove() : Object
  1130.    {
  1131.       var removed:Object;
  1132.       var oldIndex:int = 0;
  1133.       var message:String = null;
  1134.       if(Boolean(beforeFirst) || Boolean(afterLast))
  1135.       {
  1136.          message = resourceManager.getString("collections","invalidRemove");
  1137.          throw new CursorError(message);
  1138.       }
  1139.       oldIndex = int(currentIndex);
  1140.       ++currentIndex;
  1141.       if(currentIndex >= view.length)
  1142.       {
  1143.          currentIndex = AFTER_LAST_INDEX;
  1144.          setCurrent(null);
  1145.       }
  1146.       else
  1147.       {
  1148.          try
  1149.          {
  1150.             setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1151.          }
  1152.          catch(e:ItemPendingError)
  1153.          {
  1154.             setCurrent(null,false);
  1155.             ListCollectionView(view).removeItemAt(oldIndex);
  1156.             throw e;
  1157.          }
  1158.       }
  1159.       removed = ListCollectionView(view).removeItemAt(oldIndex);
  1160.       return removed;
  1161.    }
  1162.    
  1163.    private function setCurrent(param1:Object, param2:Boolean = true) : void
  1164.    {
  1165.       currentValue = param1;
  1166.       if(param2)
  1167.       {
  1168.          dispatchEvent(new FlexEvent(FlexEvent.CURSOR_UPDATE));
  1169.       }
  1170.    }
  1171.    
  1172.    public function seek(param1:CursorBookmark, param2:int = 0, param3:int = 0) : void
  1173.    {
  1174.       var newIndex:int;
  1175.       var newCurrent:Object;
  1176.       var message:String = null;
  1177.       var bookmark:CursorBookmark = param1;
  1178.       var offset:int = param2;
  1179.       var prefetch:int = param3;
  1180.       checkValid();
  1181.       if(view.length == 0)
  1182.       {
  1183.          currentIndex = AFTER_LAST_INDEX;
  1184.          setCurrent(null,false);
  1185.          return;
  1186.       }
  1187.       newIndex = int(currentIndex);
  1188.       if(bookmark == CursorBookmark.FIRST)
  1189.       {
  1190.          newIndex = 0;
  1191.       }
  1192.       else if(bookmark == CursorBookmark.LAST)
  1193.       {
  1194.          newIndex = view.length - 1;
  1195.       }
  1196.       else if(bookmark != CursorBookmark.CURRENT)
  1197.       {
  1198.          try
  1199.          {
  1200.             newIndex = ListCollectionView(view).mx_internal::getBookmarkIndex(bookmark);
  1201.             if(newIndex < 0)
  1202.             {
  1203.                setCurrent(null);
  1204.                message = resourceManager.getString("collections","bookmarkInvalid");
  1205.                throw new CursorError(message);
  1206.             }
  1207.          }
  1208.          catch(bmError:CollectionViewError)
  1209.          {
  1210.             message = resourceManager.getString("collections","bookmarkInvalid");
  1211.             throw new CursorError(message);
  1212.          }
  1213.       }
  1214.       newIndex += offset;
  1215.       newCurrent = null;
  1216.       if(newIndex >= view.length)
  1217.       {
  1218.          currentIndex = AFTER_LAST_INDEX;
  1219.       }
  1220.       else if(newIndex < 0)
  1221.       {
  1222.          currentIndex = BEFORE_FIRST_INDEX;
  1223.       }
  1224.       else
  1225.       {
  1226.          newCurrent = ListCollectionView(view).getItemAt(newIndex,prefetch);
  1227.          currentIndex = newIndex;
  1228.       }
  1229.       setCurrent(newCurrent);
  1230.    }
  1231.    
  1232.    public function insert(param1:Object) : void
  1233.    {
  1234.       var _loc2_:int = 0;
  1235.       var _loc3_:String = null;
  1236.       if(afterLast)
  1237.       {
  1238.          _loc2_ = int(view.length);
  1239.       }
  1240.       else if(beforeFirst)
  1241.       {
  1242.          if(view.length > 0)
  1243.          {
  1244.             _loc3_ = resourceManager.getString("collections","invalidInsert");
  1245.             throw new CursorError(_loc3_);
  1246.          }
  1247.          _loc2_ = 0;
  1248.       }
  1249.       else
  1250.       {
  1251.          _loc2_ = int(currentIndex);
  1252.       }
  1253.       ListCollectionView(view).addItemAt(param1,_loc2_);
  1254.    }
  1255.    
  1256.    [Bindable("cursorUpdate")]
  1257.    public function get afterLast() : Boolean
  1258.    {
  1259.       checkValid();
  1260.       return currentIndex == AFTER_LAST_INDEX || view.length == 0;
  1261.    }
  1262.    
  1263.    private function checkValid() : void
  1264.    {
  1265.       var _loc1_:String = null;
  1266.       if(invalid)
  1267.       {
  1268.          _loc1_ = resourceManager.getString("collections","invalidCursor");
  1269.          throw new CursorError(_loc1_);
  1270.       }
  1271.    }
  1272.    
  1273.    private function collectionEventHandler(param1:CollectionEvent) : void
  1274.    {
  1275.       var event:CollectionEvent = param1;
  1276.       switch(event.kind)
  1277.       {
  1278.          case CollectionEventKind.ADD:
  1279.             if(event.location <= currentIndex)
  1280.             {
  1281.                currentIndex += event.items.length;
  1282.             }
  1283.             break;
  1284.          case CollectionEventKind.REMOVE:
  1285.             if(event.location < currentIndex)
  1286.             {
  1287.                currentIndex -= event.items.length;
  1288.             }
  1289.             else if(event.location == currentIndex)
  1290.             {
  1291.                if(currentIndex < view.length)
  1292.                {
  1293.                   try
  1294.                   {
  1295.                      setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1296.                   }
  1297.                   catch(error:ItemPendingError)
  1298.                   {
  1299.                      setCurrent(null,false);
  1300.                   }
  1301.                }
  1302.                else
  1303.                {
  1304.                   currentIndex = AFTER_LAST_INDEX;
  1305.                   setCurrent(null);
  1306.                }
  1307.             }
  1308.             break;
  1309.          case CollectionEventKind.MOVE:
  1310.             if(event.oldLocation == currentIndex)
  1311.             {
  1312.                currentIndex = event.location;
  1313.             }
  1314.             else
  1315.             {
  1316.                if(event.oldLocation < currentIndex)
  1317.                {
  1318.                   currentIndex -= event.items.length;
  1319.                }
  1320.                if(event.location <= currentIndex)
  1321.                {
  1322.                   currentIndex += event.items.length;
  1323.                }
  1324.             }
  1325.             break;
  1326.          case CollectionEventKind.REFRESH:
  1327.             if(!(Boolean(beforeFirst) || Boolean(afterLast)))
  1328.             {
  1329.                currentIndex = ListCollectionView(view).getItemIndex(currentValue);
  1330.                if(currentIndex == -1)
  1331.                {
  1332.                   setCurrent(null);
  1333.                }
  1334.             }
  1335.             break;
  1336.          case CollectionEventKind.REPLACE:
  1337.             if(event.location == currentIndex)
  1338.             {
  1339.                try
  1340.                {
  1341.                   setCurrent(ListCollectionView(view).getItemAt(currentIndex));
  1342.                }
  1343.                catch(error:ItemPendingError)
  1344.                {
  1345.                   setCurrent(null,false);
  1346.                }
  1347.             }
  1348.             break;
  1349.          case CollectionEventKind.RESET:
  1350.             currentIndex = BEFORE_FIRST_INDEX;
  1351.             setCurrent(null);
  1352.       }
  1353.    }
  1354.    
  1355.    public function moveNext() : Boolean
  1356.    {
  1357.       if(afterLast)
  1358.       {
  1359.          return false;
  1360.       }
  1361.       var _loc1_:int = !!beforeFirst ? 0 : int(currentIndex + 1);
  1362.       if(_loc1_ >= view.length)
  1363.       {
  1364.          _loc1_ = int(AFTER_LAST_INDEX);
  1365.          setCurrent(null);
  1366.       }
  1367.       else
  1368.       {
  1369.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1370.       }
  1371.       currentIndex = _loc1_;
  1372.       return !afterLast;
  1373.    }
  1374.    
  1375.    public function get view() : ICollectionView
  1376.    {
  1377.       checkValid();
  1378.       return _view;
  1379.    }
  1380.    
  1381.    public function movePrevious() : Boolean
  1382.    {
  1383.       if(beforeFirst)
  1384.       {
  1385.          return false;
  1386.       }
  1387.       var _loc1_:int = !!afterLast ? int(view.length - 1) : int(currentIndex - 1);
  1388.       if(_loc1_ == -1)
  1389.       {
  1390.          _loc1_ = int(BEFORE_FIRST_INDEX);
  1391.          setCurrent(null);
  1392.       }
  1393.       else
  1394.       {
  1395.          setCurrent(ListCollectionView(view).getItemAt(_loc1_));
  1396.       }
  1397.       currentIndex = _loc1_;
  1398.       return !beforeFirst;
  1399.    }
  1400.    
  1401.    public function findLast(param1:Object) : Boolean
  1402.    {
  1403.       var lcView:ListCollectionView;
  1404.       var index:int = 0;
  1405.       var values:Object = param1;
  1406.       checkValid();
  1407.       lcView = ListCollectionView(view);
  1408.       try
  1409.       {
  1410.          index = lcView.mx_internal::findItem(values,Sort.LAST_INDEX_MODE);
  1411.       }
  1412.       catch(sortError:SortError)
  1413.       {
  1414.          throw new CursorError(sortError.message);
  1415.       }
  1416.       if(index > -1)
  1417.       {
  1418.          currentIndex = index;
  1419.          setCurrent(lcView.getItemAt(currentIndex));
  1420.       }
  1421.       return index > -1;
  1422.    }
  1423.    
  1424.    [Bindable("cursorUpdate")]
  1425.    public function get beforeFirst() : Boolean
  1426.    {
  1427.       checkValid();
  1428.       return currentIndex == BEFORE_FIRST_INDEX || view.length == 0;
  1429.    }
  1430.    
  1431.    [Bindable("cursorUpdate")]
  1432.    public function get bookmark() : CursorBookmark
  1433.    {
  1434.       checkValid();
  1435.       if(view.length == 0 || Boolean(beforeFirst))
  1436.       {
  1437.          return CursorBookmark.FIRST;
  1438.       }
  1439.       if(afterLast)
  1440.       {
  1441.          return CursorBookmark.LAST;
  1442.       }
  1443.       return ListCollectionView(view).mx_internal::getBookmark(currentIndex);
  1444.    }
  1445.    
  1446.    public function findFirst(param1:Object) : Boolean
  1447.    {
  1448.       var lcView:ListCollectionView;
  1449.       var index:int = 0;
  1450.       var values:Object = param1;
  1451.       checkValid();
  1452.       lcView = ListCollectionView(view);
  1453.       try
  1454.       {
  1455.          index = lcView.mx_internal::findItem(values,Sort.FIRST_INDEX_MODE);
  1456.       }
  1457.       catch(sortError:SortError)
  1458.       {
  1459.          throw new CursorError(sortError.message);
  1460.       }
  1461.       if(index > -1)
  1462.       {
  1463.          currentIndex = index;
  1464.          setCurrent(lcView.getItemAt(currentIndex));
  1465.       }
  1466.       return index > -1;
  1467.    }
  1468.    
  1469.    [Bindable("cursorUpdate")]
  1470.    public function get current() : Object
  1471.    {
  1472.       checkValid();
  1473.       return currentValue;
  1474.    }
  1475. }
  1476.